package com.github.sevenmall.orderservice.controller;

import com.github.sevenmall.orderservice.pojo.do0.SevenmallCart;
import com.github.sevenmall.orderservice.service.CartService;
import com.github.sevenmall.orderservice.util.*;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/cart")
public class CartController {
    @Autowired
    private CartService cartService;
    /*
    需要添加商品服务 productService
        商品货品服务skuService
         地址服务addressService
     */


    /**
     * 用户购物车信息
     *
     * @param userId 用户ID
     * @return 用户购物车信息
     */
    @GetMapping("index")
    public Object index(Integer userId) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }
        //查询用户在购物车的商品信息
        List<SevenmallCart> list = cartService.queryByUid(userId);
        List<SevenmallCart> cartList = new ArrayList<>();
        // 如果系统检查商品已删除或已下架，则系统自动删除。
        // 更好的效果应该是告知用户商品失效，允许用户点击按钮来清除失效商品。
        for (SevenmallCart cart : list) {
            //查询品是否存在
            /*
            此部分需要查询商品服务那边的情况
             */
//            SevenmallGoods goods = goodsService.findById(cart.getProductId());
//            if (goods == null || !goods.getIsOnSale()) {
//                cartService.deleteById(cart.getId());
////                logger.debug("系统自动删除失效购物车商品 goodsId=" + cart.getGoodsId() + " productId=" + cart.getProductId());
//            }
//            else{
//                cartList.add(cart);
//            }
        }

        Integer productsCount = 0;
        BigDecimal productsAmount = new BigDecimal(0.00);
        Integer checkedProductsCount = 0;
        BigDecimal checkedProductsAmount = new BigDecimal(0.00);
        for (SevenmallCart cart : cartList) {
            productsCount += cart.getNumber();
            productsAmount = productsAmount.add(cart.getPrice().multiply(new BigDecimal(cart.getNumber())));
            if (cart.getChecked()) {
                checkedProductsCount += cart.getNumber();
                checkedProductsAmount = checkedProductsAmount.add(cart.getPrice().multiply(new BigDecimal(cart.getNumber())));
            }
        }
        Map<String, Object> cartTotal = new HashMap<>();
        cartTotal.put("goodsCount", productsCount);
        cartTotal.put("goodsAmount", productsAmount);
        cartTotal.put("checkedGoodsCount", checkedProductsCount);
        cartTotal.put("checkedGoodsAmount", checkedProductsAmount);

        Map<String, Object> result = new HashMap<>();
        result.put("cartList", cartList);
        result.put("cartTotal", cartTotal);

        return ResponseUtil.ok(result);
    }

    /**
     * 加入商品到购物车
     * <p>
     * 如果已经存在购物车货品，则增加数量；
     * 否则添加新的购物车货品项。
     *
     * @param userId 用户ID
     * @param cart   购物车商品信息， { productId: xxx, skuId: xxx, number: xxx }
     * @return 加入购物车操作结果
     */
    @PostMapping("addCart")
    public Object addCart( Integer userId, @RequestBody SevenmallCart cart) {
        //先对要添加的购物车信息进行判断
        if (userId == null) {
            return ResponseUtil.unlogin();
        }
        if (cart == null) {
            return ResponseUtil.badArgument();
        }

        Integer skuId = cart.getSkuId();
        Integer number = cart.getNumber().intValue();
        Integer productId = cart.getProductId();
        if (skuId==null || number ==null || productId ==null || number<=0) {
            return ResponseUtil.badArgument();
        }

        //判断商品是否可以购买
        //product商品
//        LitemallGoods goods = goodsService.findById(goodsId);
//        if (goods == null || !goods.getIsOnSale()) {
//            return ResponseUtil.fail(GOODS_UNSHELVE, "商品已下架");
//        }
       //货品sku,获取sku的信息
       // LitemallGoodsProduct sku = productService.findById(skuId);
        //判断购物车中是否存在此规格商品
        SevenmallCart existCart = cartService.queryExist(productId, skuId, userId);
        if (existCart == null) {
            //取得规格的信息,判断规格库存  货品不存在或者货品库存不足
            if (sku == null || number > sku.getNumber()) {
                return ResponseUtil.fail(ResponseUtil.GOODS_NO_STOCK, "库存不足");
            }

            cart.setId(null);
            cart.setProductName((product.getName()));
            if(StringUtils.isEmpty(sku.getUrl())){
                cart.setPicUrl(product.getPicUrl());
            }
            else{
                cart.setPicUrl(sku.getUrl());
            }
            cart.setPrice(sku.getPrice());
            cart.setSkuValue(sku.getValue());
            cart.setUserId(userId);
            cart.setChecked(true);
            cartService.addCart(cart);
        } else {
            //取得规格的信息,判断规格库存
            int num = existCart.getNumber() + number;
            if (num > sku.getNumber()) {
                return ResponseUtil.fail(ResponseUtil.GOODS_NO_STOCK, "库存不足");
            }
            existCart.setNumber((short) num);
            if (cartService.updateById(existCart) == 0) {
                return ResponseUtil.updatedDataFailed();
            }
        }
          //返回购物车商品货品数量
        return skucount(userId);
    }

    /**
     * 返回购物车商品货品数量
     * <p>
     * 如果用户没有登录，则返回空数据。
     *
     * @param userId 用户ID
     * @return 购物车商品货品数量
     */
    @GetMapping("skucount")
    public Object skucount(Integer userId) {
        //用户没有登录
        if (userId == null) {
            return ResponseUtil.ok(0);
        }

        int skuCount = 0;
        List<SevenmallCart> cartList = cartService.queryByUid(userId);
        for (SevenmallCart cart : cartList) {
            skuCount += cart.getNumber();
        }

        return ResponseUtil.ok(skuCount);
    }

    /**
     * 修改购物车商品货品数量
     *
     * @param userId 用户ID
     * @param cart   购物车商品信息， { id: xxx, producrId: xxx, skuId: xxx, number: xxx }
     * @return 修改结果
     */
    @PostMapping("update")
    public Object update(Integer userId, @RequestBody SevenmallCart cart) {
        //用户没有登录
        if (userId == null) {
            return ResponseUtil.unlogin();
        }
        Integer productId = cart.getProductId();
        Integer number = cart.getNumber().intValue();
        Integer skuId = cart.getSkuId();
        Integer id = cart.getId();
        if (!ObjectUtils.allNotNull(id, productId, number, skuId)) {
            return ResponseUtil.badArgument();
        }
        if(number <= 0){
            return ResponseUtil.badArgument();
        }

        //判断是否存在该购物车信息
        // 如果不存在，直接返回错误
        SevenmallCart existCart = cartService.findById(userId, id);
        if (existCart == null) {
            return ResponseUtil.badArgumentValue();
        }

        // 判断skuId和productId是否与当前cart里的值一致
        if (!existCart.getProductId().equals(productId)) {
            return ResponseUtil.badArgumentValue();
        }
        if (!existCart.getSkuId().equals(skuId)) {
            return ResponseUtil.badArgumentValue();
        }

        //判断商品是否可以购买
        Product product = productService.findById(productId);
        if (product == null || !product.getIsOnSale()) {
            return ResponseUtil.fail(ResponseUtil.GOODS_UNSHELVE, "商品已下架");
        }

        //取得规格的信息,判断规格库存
       //  sku = productService.findById(skuId);
        if (sku == null || sku.getNumber() < number) {
            return ResponseUtil.fail(ResponseUtil.GOODS_UNSHELVE, "库存不足");
        }

        existCart.setNumber(number.shortValue());
        if (cartService.updateById(existCart) == 0) {
            return ResponseUtil.updatedDataFailed();
        }
        return ResponseUtil.ok();
    }


    /**
     * 购物车商品删除
     *
     * @param userId 用户ID
     * @param body   购物车商品信息， { skuIds: xxx }
     * @return 购物车信息
     * 成功则
     * {
     * errno: 0,
     * errmsg: '成功',
     * data: xxx
     * }
     * 失败则 { errno: XXX, errmsg: XXX }
     */
    @PostMapping("delete")
    public Object delete(Integer userId, @RequestBody String body) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }
        if (body == null) {
            return ResponseUtil.badArgument();
        }

        List<Integer> skuIds = JacksonUtil.parseIntegerList(body, "skuIds");

        if (skuIds == null || skuIds.size() == 0) {
            return ResponseUtil.badArgument();
        }

        cartService.delete(skuIds, userId);
        return index(userId);
    }

    /**
     * 购物车商品货品勾选状态
     * <p>
     * 如果原来没有勾选，则设置勾选状态；如果商品已经勾选，则设置非勾选状态。
     *
     * @param userId 用户ID
     * @param body   购物车商品信息， { skuIds: xxx, isChecked: 1/0 }
     * @return 购物车信息
     */
    @PostMapping("checked")
    public Object checked(Integer userId, @RequestBody String body) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }
        if (body == null) {
            return ResponseUtil.badArgument();
        }

        List<Integer> skuIds = JacksonUtil.parseIntegerList(body, "skuIds");
        if (skuIds == null) {
            return ResponseUtil.badArgument();
        }

        Integer checkValue = JacksonUtil.parseInteger(body, "isChecked");
        if (checkValue == null) {
            return ResponseUtil.badArgument();
        }
        Boolean isChecked = (checkValue == 1);

        cartService.updateCheck(userId, skuIds, isChecked);
        return index(userId);
    }

    /**
     * 购物车下单
     *
     * @param userId    用户ID
     * @param cartId    购物车商品ID：
     *                  如果购物车商品ID是空，则下单当前用户所有购物车商品；
     *                  如果购物车商品ID非空，则只下单当前购物车商品。
     * @param addressId 收货地址ID：
     *                  如果收货地址ID是空，则查询当前用户的默认地址。
     * @return 购物车操作结果
     */
    @GetMapping("checkout")
    public Object checkout( Integer userId, Integer cartId, Integer addressId) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }

        // 收货地址
        SevenmallAddress checkedAddress = null;
        if (addressId == null || addressId.equals(0)) {
            //根据用户ID获取收货人地址
            checkedAddress = addressService.findDefault(userId);
            // 如果仍然没有地址，则是没有收货地址
            // 返回一个空的地址id=0，这样前端则会提醒添加地址
            if (checkedAddress == null) {
                checkedAddress = new SevenmallAddress();
                checkedAddress.setId(0);
                addressId = 0;
            } else {
                addressId = checkedAddress.getId();
            }

        } else {
            checkedAddress = addressService.query(userId, addressId);
            // 如果null,表示收货地址跟用户不匹配， 则报错
            if (checkedAddress == null) {
                return ResponseUtil.badArgumentValue();
            }
        }

        // 商品价格
        List<SevenmallCart> checkedProductsList = null;
        //结算购物车的所有东西
        if (cartId == null || cartId.equals(0)) {
            checkedProductsList = cartService.queryByUidAndChecked(userId);
        } else {
            SevenmallCart cart = cartService.findById(userId, cartId);
            if (cart == null) {
                return ResponseUtil.badArgumentValue();
            }
            checkedProductsList = new ArrayList<>(1);
            checkedProductsList.add(cart);
        }
        BigDecimal checkedProductsPrice = new BigDecimal(0.00);
        for (SevenmallCart cart : checkedProductsList) {
            checkedProductsPrice = checkedProductsPrice.add(cart.getPrice().multiply(new BigDecimal(cart.getNumber())));

        }

        // 订单费用
       BigDecimal actualPrice = checkedProductsPrice;

        Map<String, Object> data = new HashMap<>();
        data.put("addressId", addressId);
        data.put("cartId", cartId);
        data.put("checkedAddress", checkedAddress);
        data.put("goodsTotalPrice", checkedGoodsPrice);
        data.put("actualPrice", actualPrice);
        data.put("checkedGoodsList", checkedGoodsList);
        return ResponseUtil.ok(data);
    }

    /**
     * 立即购买
     * <p>
     * 和add方法的区别在于：
     * 1. 如果购物车内已经存在购物车货品，前者的逻辑是数量添加，这里的逻辑是数量覆盖
     * 2. 添加成功以后，前者的逻辑是返回当前购物车商品数量，这里的逻辑是返回对应购物车项的ID
     *
     * @param userId 用户ID
     * @param cart   购物车商品信息， { productId: xxx, skuId: xxx, number: xxx }
     * @return 立即购买操作结果
     */
    @PostMapping("fastadd")
    public Object fastadd(Integer userId, @RequestBody SevenmallCart cart) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }
        if (cart == null) {
            return ResponseUtil.badArgument();
        }

        Integer skuId = cart.getSkuId();
        Integer number = cart.getNumber().intValue();
        Integer productId = cart.getProductId();
        if (!ObjectUtils.allNotNull(skuId, number, productId)) {
            return ResponseUtil.badArgument();
        }
        if(number <= 0){
            return ResponseUtil.badArgument();
        }

        //判断商品是否可以购买
        SevenmallProduct product = productService.findById(productId);
        if (product == null || !product.getIsOnSale()) {
            return ResponseUtil.fail(ResponseUtil.GOODS_UNSHELVE, "商品已下架");
        }

        SevenmallGoodsProduct sku = skuService.findById(skuId);
        //判断购物车中是否存在此规格商品
        SevenmallCart existCart = cartService.queryExist(productId, skuId, userId);
        if (existCart == null) {
            //取得规格的信息,判断规格库存
            if (sku == null || number > sku.getNumber()) {
                return ResponseUtil.fail(ResponseUtil.GOODS_NO_STOCK, "库存不足");
            }

            cart.setId(null);
            cart.setProductName((sku.getName()));
            if(StringUtils.isEmpty(sku.getUrl())){
                cart.setPicUrl(product.getPicUrl());
            }
            else{
                cart.setPicUrl(sku.getUrl());
            }
            cart.setPrice(sku.getPrice());
            cart.setSkuValue(sku.getValue());
            cart.setUserId(userId);
            cart.setChecked(true);
            cartService.add(cart);
        } else {
            //取得规格的信息,判断规格库存
            int num = number;
            if (num > sku.getNumber()) {
                return ResponseUtil.fail(ResponseUtil.GOODS_NO_STOCK, "库存不足");
            }
            existCart.setNumber((short) num);
            if (cartService.updateById(existCart) == 0) {
                return ResponseUtil.updatedDataFailed();
            }
        }

        return ResponseUtil.ok(existCart != null ? existCart.getId() : cart.getId());
    }

}
